package Proyecto_UF3_Alejandro_Alejandro;

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * Dispone de todos los métodos necesarios para el intercambio de información
 * entre el usuario y la máquina (entrada de datos, validación de los mismos,
 * etc.
 *
 * @author Alejandro Gomez y Alejandro Aguirre
 */
public class EntradaSalida {

    /**
     * Muestra por pantalla el menú principal de la aplicación con todas las
     * opciones disponibles
     *
     * @return Devuelve en forma de entero la opción escogida por el usuario
     */
    //Mostramos al usuario el menú principal de la aplicación
    public int menuPrincipal() {
        int opcion;
        Scanner lector = new Scanner(System.in);

        System.out.println("1. Añadir maquina\n"
                + "2. Eliminar maquina\n"
                + "3. Modificar maquina\n"
                + "4. Nueva busqueda\n"
                + "5. Mostrar busqueda almacenada\n"
                + "6. Salir\n"
                + "Escoged una opción del menú (1 a 6):");

        while (true) {
            if (!lector.hasNextInt()) {
                lector.next();
                System.out.println("Valor no entero, volver a introducirlo: ");
            } else {
                opcion = lector.nextInt();
                if ((opcion < 1) || (opcion > 6)) {
                    System.out.println("Valor no válido, volver a introducirlo "
                            + "(entre 1 y 6): ");
                } else {
                    break;
                }
            }
        }
        return opcion;
    }

    /**
     * Muestra por pantalla el submenú de búsqueda, donde el usuario puede
     * decidir el criterio que utilizará cuando quiera realizar una búsqueda en
     * el fichero donde están almacenadas las máquinas
     *
     * @return Devuelve en forma de entero la opción escogida por el usuario
     */
    //Mostramos el menú de la búsqueda
    public int menuBusqueda() {
        int opcion;
        Scanner lector = new Scanner(System.in);

        System.out.println("1. Codigo\n"
                + "2. Marca\n"
                + "3. CPU\n"
                + "4. Rango de disco\n"
                + "5. Rango de memoria\n"
                + "6. Estado\n"
                + "7. Volver\n"
                + "Escoged una opción del menú (1 a 7):");

        while (true) {
            if (!lector.hasNextInt()) {
                lector.next();
                System.out.println("Valor no entero, volver a introducirlo: ");
            } else {
                opcion = lector.nextInt();
                if ((opcion < 1) || (opcion > 7)) {
                    System.out.println("Valor no válido, volver a introducirlo "
                            + "(entre 1 y 7): ");
                } else {
                    break;
                }
            }
        }
        return opcion;
    }

    /**
     * Controla que la marca de la máquina sea una cadena de carácteres (String)
     * de medida fija (20), y rellena con espacios en blanco si es necesario
     * para cumplir con este requisito.
     *
     * @return Devuelve la cadena de carácteres "marca" con medida fija de 20
     */
    //Validamos entrada de cadena de 20 caracteres para Marca 
    public String validarMarca() {
        Scanner lector = new Scanner(System.in);
        String marca;

        System.out.println("Introduce la marca de la máquina "
                + "(max. 20 caracters)");

        while (true) {
            marca = lector.nextLine();

            if (marca.length() > 20) {
                System.out.println("Marca no válida, vuelve a introducir "
                        + "(max 20 car.)");
                continue;
            } else {
                for (int i = marca.length(); i < 20; i++) {
                    marca += " ";
                }
                break;
            }
        }
        marca = marca.toUpperCase();
        return marca;
    }

    /**
     * Controla que la capacidad de almacenamiento de la máquina sea un valor
     * entero y positivo.
     *
     * @return Devuelve un valor del tipo entero i positivo.
     */
    //Validamos entero positivo para capacidad HD
    public int validarCapacidadDisco() {
        Scanner lector = new Scanner(System.in);
        int valor;

        System.out.println("Introduce la capacidad del disco duro:");

        while (true) {

            if (!lector.hasNextInt()) {
                System.out.println("Tienes que introducir un valor entero.");
                lector.nextLine();
                continue;
            } else {
                valor = lector.nextInt();

                if (valor < 0) {
                    System.out.println("Tienes que introducir un valor "
                            + "positivo.");
                    lector.nextLine();
                    continue;
                } else {
                    break;
                }
            }
        }
        return valor;
    }

    /**
     * Controla que la cpu de la máquina sea una cadena de carácteres (String)
     * de medida fija (30), y rellena con espacios en blanco si es necesario
     * para cumplir con este requisito.
     *
     * @return Devuelve la cadena de carácteres "cpu" con medida fija de 20
     */
    //Validamos entrada de cadena de 30 caracteres para CPU
    public String validarCPU() {
        Scanner lector = new Scanner(System.in);
        String cpu;

        System.out.println("Introduce la CPU de la máquina "
                + "(max. 30 caracteres)");

        while (true) {
            cpu = lector.nextLine();

            if (cpu.length() > 30) {
                System.out.println("Marca no válida, vuelve a introducir "
                        + "(max 30 car.)");
                continue;
            } else if (cpu.length() == 30) {
                break;
            } else {
                for (int i = 0; cpu.length() < 30; i++) {
                    cpu += " ";
                }
                break;
            }
        }
        cpu = cpu.toUpperCase();
        return cpu;
    }

    /**
     * Controla que la memoria ram de la máquina sea una variable del tipo
     * double y positivo.
     *
     * @return Devuelve un valor double positivo.
     */
    //Validamos double positivo para memoria RAM
    public double validarRAM() {
        Scanner lector = new Scanner(System.in);
        double ram;

        System.out.println("Introduce la memoria RAM");

        while (true) {
            if (!lector.hasNextDouble()) {
                System.out.println("Valor no válido, introduce memoria "
                        + "de nuevo.");
                lector.nextLine();
                continue;
            } else {
                ram = lector.nextDouble();

                if (ram < 0) {
                    System.out.println("No puedes introducir un valor negativo "
                            + "para indicar la memoria. Introduce nuevo valor");
                    lector.nextLine();
                    continue;
                } else {
                    break;
                }
            }
        }
        return ram;
    }

    /**
     * Controla que el código de máquina introducido por el usuario cumple con
     * los requisitos necesarios (5 caracteres).
     *
     * @return Devuelve el código de máquina validado en forma de String
     */
    //Validamos entrada de 5 caracteres para la busqueda por codigo
    public String validarCodigo() {
        Scanner lector = new Scanner(System.in);
        String codigo;

        System.out.println("Introduce el codigo de la máquina "
                + "(5 caracteres)");

        while (true) {
            codigo = lector.nextLine();
            if (codigo.length() != 5) {
                System.out.println("El código está formado por 5 "
                        + "carácteres. Por favor, introduce un código"
                        + " válido");
                //lector.nextLine();
                continue;
            } else {
                break;
            }
        }
        return codigo;
    }

    /**
     * Controla que el estado de máquina introducido por el usuario es uno de
     * los tres valores permitidos (0, 1 y 2).
     *
     * @return Devuelve el valor introducido por el usuario del tipo byte.
     */
//Validamos entrada del estado de la maquina (0, 1 o 2)
    public byte validarEstado() {
        Scanner lector = new Scanner(System.in);
        byte estado;
        System.out.println("Introduce el estado de la maquina:\n"
                + "0: Estropeado\t1: Funcionando\t2: Disponible pero"
                + "no utilizada");

        while (true) {

            if (!lector.hasNextByte()) {
                System.out.println("Tienes que introducir 0, 1 o 2");
                lector.nextLine();
                continue;

            } else {
                estado = lector.nextByte();
                if ((estado == 0) || (estado == 1) || (estado == 2)) {
                    break;
                } else {
                    System.out.println("Tienes que introducir 0, 1 o 2");
                    lector.nextLine();
                    continue;
                }
            }
        }
        return estado;
    }

    /**
     * Formatea la búsqueda de un solo resultado realizada por el usuario para
     * hacer el resultado de ésta mucho más agradable a la vista.
     *
     * @param Entra la cadena de carácteres a formatear
     */
    public void formatearResultadoBusquedaString(String busqueda) {
        Scanner lector = new Scanner(busqueda).useDelimiter(":");

        System.out.print("CODI:\t");
        System.out.println(lector.next());
        System.out.print("MARCA:\t");
        System.out.println(lector.next());
        System.out.print("CPU:\t");
        System.out.println(lector.next());
        System.out.print("DISC:\t");
        System.out.println(lector.next());
        System.out.print("RAM:\t");
        System.out.println(lector.next());
        System.out.print("ESTAT:\t");
        System.out.println(lector.next());
    }

    /**
     * Formatea la búsqueda multiresultado realizada por el usuario para hacer
     * el resultado de ésta mucho más agradable a la vista.
     *
     * @param busqueda Entra un arraylist con el conjunto de Strings a
     * formatear.
     */
    public void formatearResultadoBusquedaList(ArrayList<String> busqueda) {
        int contador = 0;
        for (String i : busqueda) {
            contador += 1;
            Scanner lector = new Scanner(i).useDelimiter(":");
            System.out.println("MAQUINA " + contador);
            System.out.print("CODI:\t");
            System.out.println(lector.next());
            System.out.print("MARCA:\t");
            System.out.println(lector.next());
            System.out.print("CPU:\t");
            System.out.println(lector.next());
            System.out.print("DISC:\t");
            System.out.println(lector.next());
            System.out.print("RAM:\t");
            System.out.println(lector.next());
            System.out.print("ESTAT:\t");
            System.out.println(lector.next());
            System.out.println();
        }

    }

    /**
     * Auxiliar para los métodos de búsqueda, solicita al usuario si quiere que
     * el resultado de la búsqueda se guarde en un archivo.
     *
     * @return Devuelve true si el usuario quiere guardar la búsqueda, false en
     * caso contrario.
     */
    public boolean preguntarGuardarBusqueda() {
        Scanner lector = new Scanner(System.in);
        String respuesta;
        boolean guardar;

        System.out.println("¿Quieres guardar la busqueda? (introducir S o N)");

        while (true) {
            respuesta = lector.next();
            if (respuesta.matches("[sS]")) {
                guardar = true;
                break;
            } else if (respuesta.matches("[nN]")) {
                guardar = false;
                break;
            } else {
                System.out.println("Valor no válido, introducir S o N!!");
                lector.nextLine();
                continue;
            }
        }
        return guardar;
    }

    /**
     * Utilizado por el método de guardar búsqueda, le pide al usuario el nombre
     * del fichero en el que quiere guardar su búsqueda.
     *
     * @return Devuelve un String con el nombre introducido por el usuario.
     */
    //Auxiliar de guardarBusqueda, para solicitar el nombre del fichero
    public String pedirNombreFichero() {
        Scanner lector = new Scanner(System.in);
        System.out.println("Introduce el nombre que tendrá el fichero que "
                + "va a almacenar las búsquedas");
        String nom = lector.nextLine();
        return nom;
    }

    /**
     * Muestra los ficheros que se encuentran actualmente en el directorio
     * "Cerques" y le permite visualizar al usuario el que seleccione.
     */
    public void mostrarBusquedaAlmacenada() {
        File f1 = new File(GestionFicheros.DIRECTORIO);

        File[] ficheros = f1.listFiles();

        if (ficheros.length == 0) {
            System.out.println("Lo sentimos, no hay ninguna búsqueda "
                    + "almacenada");
        } else {

            int numBusqueda;

            //Mostramos listado de ficheros en carpeta de Cerques
            for (int i = 0; i < ficheros.length; i++) {
                System.out.println((i + 1) + "  " + ficheros[i]);
            }
            Scanner lector = new Scanner(System.in);

            while (true) {
                if (!lector.hasNextInt()) {
                    System.out.println("Tienes que introducir un numero "
                            + "entero");
                    lector.nextLine();
                    continue;
                } else {
                    numBusqueda = lector.nextInt();
                    int cantidad = ficheros.length;

                    if ((numBusqueda <= cantidad) && (numBusqueda > 0)) {
                        break;
                    } else {
                        System.out.println("Valor no válido");
                        continue;
                    }
                }
            }

            lector = null;

            try {
                lector = new Scanner(ficheros[numBusqueda - 1])
                        .useDelimiter(":");
                int contador = 0;
                /*No sabemos porque aquí al mostrar las máquinas, se nos va el
                 * lector y nos muestra un poco más de la cuenta*/
                while (lector.hasNextLine()) {
                    contador += 1;
                    System.out.println("MAQUINA " + contador);
                    System.out.print("CODI:\t");
                    System.out.println(lector.next());
                    System.out.print("MARCA:\t");
                    System.out.println(lector.next());
                    System.out.print("CPU:\t");
                    System.out.println(lector.next());
                    System.out.print("DISC:\t");
                    System.out.println(lector.next());
                    System.out.print("RAM:\t");
                    System.out.println(lector.next());
                    System.out.print("ESTAT:\t");
                    System.out.println(lector.next());
                    System.out.println();
                }
            } catch (Exception e) {
                e.getMessage();
            }
            GestionFicheros.intentarCerrar(lector);
        }
    }
}
